home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 July: Mac OS SDK / Dev.CD Jul 96 SDK / Dev.CD Jul 96 SDK2.toast / Development Kits (Disc 2) / QuickDraw GX / Programming Stuff / GX Libraries / ColorLibrary.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-31  |  14.2 KB  |  553 lines  |  [TEXT/MPS ]
  1.  
  2. /*
  3.     File:        ColorLibrary.c
  4.  
  5.     Contains:    graphics libraries - gxColor library
  6.  
  7.     Written by:    Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  8.  
  9.     Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  10.  
  11.     Change History (most recent first):
  12.  
  13.          <1>      1/9/95    JD        First checked in.
  14. */
  15.  
  16. #include "GraphicsLibraries.h"
  17.  
  18. gxSetColor commonColorList[] = {
  19.     sRGB(0xffff, 0xffff, 0xffff),    /* white */
  20.     sRGB(0,0,0),                /* black */
  21.     sRGB(0x7f7f,0x7f7f,0x7f7f),    /* gray */
  22.     sRGB(0xffff,0,0),            /* red */
  23.     sRGB(0,0xffff,0),            /* green */
  24.     sRGB(0,0,0xffff),            /* blue */
  25.     sRGB(0,0xffff,0xffff),        /* cyan */
  26.     sRGB(0xffff,0,0xffff),        /* magenta */
  27.     sRGB(0xffff,0xffff,0),        /* yellow */
  28.     sRGB(0xffff,0x7f7f,0),        /* orange */
  29.     sRGB(0x7f7f,0xffff,0),        /* chartreuse */
  30.     sRGB(0,0xffff,0x7f7f),        /* aqua */
  31.     sRGB(0,0x7f7f,0xffff),        /* slate ... bluegray */
  32.     sRGB(0x7f7f,0,0xffff),        /* purple */
  33.     sRGB(0xffff,0,0x7f7f),        /* maroon */
  34.     sRGB(0x5f5f,0x3f3f,0),        /* brown */
  35.     sRGB(0xffff,0x9f9f,0xafaf),    /* pink */
  36.     sRGB(0,0xffff,0xdfdf),        /* turquoise */
  37.     sRGB256(255,227,3),        /* cadmium lemon */
  38.     sRGB256(255,176,15),        /* cadmium light yellow */
  39.     sRGB256(255,168,36),        /* aureoline yellow */
  40.     sRGB256(255,168,18),        /* naples deep yellow */
  41.     sRGB256(255,153,18),        /* cadmium yellow */
  42.     sRGB256(255,122,10),        /* cadmium deep yellow */
  43.     sRGB256(255,97,3),        /* cadmium orange */
  44.     sRGB256(255,3,13),        /* cadmium light red */
  45.     sRGB256(227,18,48),        /* cadmium deep red */
  46.     sRGB256(227,18,48),        /* geranium lake */
  47.     sRGB256(227,38,54),        /* alizarin crimson */
  48.     sRGB256(227,54,56),        /* rose madder */
  49.     sRGB256(227,46,48),        /* madder deep lake */
  50.     sRGB256(219,41,41),        /* brown madder */
  51.     sRGB256(219,38,69),        /* permanent red violet */
  52.     sRGB256(145,33,158),        /* cobalt deep violet */
  53.     sRGB256(92,36,110),        /* ultramarine violet */
  54.     sRGB256(18,10,143),        /* ultramarine blue */
  55.     sRGB256(61,89,171),        /* cobalt blue */
  56.     sRGB256(3,145,194),        /* royal blue */
  57.     sRGB256(5,184,204),        /* cerulean blue */
  58.     sRGB256(3,168,157),        /* manganese blue */
  59.     sRGB256(8,46,84),            /* indigo */
  60.     sRGB256(0,199,140),        /* turquoise blue */
  61.     sRGB256(0,201,87),        /* emerald green */
  62.     sRGB256(10,201,43),        /* permanent green */
  63.     sRGB256(110,255,112),        /* viridian light */
  64.     sRGB256(61,145,64),        /* cobalt green */
  65.     sRGB256(97,179,41),        /* cinnabar green */
  66.     sRGB256(48,128,20),        /* sap green */
  67.     sRGB256(102,128,20),        /* chromium oxide green */
  68.     sRGB256(56,94,15),        /* terre-verte */
  69.     sRGB256(227,130,23),        /* yellow ochre */
  70.     sRGB256(227,112,26),        /* mars yellow */
  71.     sRGB256(199,97,20),        /* raw sienna */
  72.     sRGB256(150,69,20),        /* mars orange */
  73.     sRGB256(199,120,38),        /* gold ochre */
  74.     sRGB256(135,66,31),        /* browh ochre */
  75.     sRGB256(115,61,36),        /* deep ochre */
  76.     sRGB256(138,51,36),        /* burnt umber */
  77.     sRGB256(138,54,15),        /* burnt sienna */
  78.     sRGB256(255,125,64),        /* flesh */
  79.     sRGB256(255,87,33),        /* flesh ochre */
  80.     sRGB256(212,61,26),        /* english red */
  81.     sRGB256(212,26,31),        /* venetian red */
  82.     sRGB256(176,23,31),        /* indian red */
  83.     sRGB256(115,74,18),        /* raw umber */
  84.     sRGB256(3,61,13),            /* greenish umber */
  85.     sRGB256(94,38,5),            /* van dyck brown */
  86.     sRGB256(94,38,18),        /* sepia */
  87.     sRGB256(128,128,105),        /* warm grey */
  88.     sRGB256(128,138,135),        /* cold grey */
  89.     sRGB256(41,36,33),        /* ivory black */
  90.     sRGB256(46,71,59),        /* lamp black */
  91.     sRGB256(252,255,240),        /* titanium white */
  92.     sRGB256(252,242,255),        /* zinc white */
  93.     sRGB256(199,171,97),        /* pale gold */
  94.     sRGB256(199,156,48),        /* gold */
  95.     sRGB256(128,110,26),        /* old gold */
  96.     sRGB256(255,179,115),        /* pink gold */
  97.     sRGB256(255,224,143),        /* white gold */
  98.     sRGB256(189,189,74),        /* yellow gold */
  99.     sRGB256(204,212,112),        /* green gold */
  100.     sRGB256(212,201,143),        /* platinum */
  101.     sRGB256(207,209,179),        /* silver */
  102.     sRGB256(135,133,120),        /* antique silver */
  103.     sRGB256(181,209,188),        /* chrome */
  104.     sRGB256(140,158,150),        /* steel */
  105.     sRGB256(247,153,71),        /* copper */
  106.     sRGB256(176,84,15),        /* antique copper */
  107.     sRGB256(128,255,176),        /* oxidized copper */
  108.     sRGB256(140,115,36),        /* bronze */
  109.     sRGB256(176,161,59),        /* brass */
  110.     sRGB256(140,158,150),        /* iron */
  111.     sRGB256(171,59,20),        /* rusted iron */
  112.     sRGB256(64,54,43),        /* lead */
  113.     sRGB256(255,214,245),        /* fluorescent pink */
  114.     sRGB256(186,255,196),        /* fluorescent green */
  115.     sRGB256(214,240,255),        /* fluorescent blue */
  116.     sRGB256(255,247,161),        /* incadescent high */
  117.     sRGB256(255,232,107),        /* incadescent low */
  118.     sRGB256(191,207,255),        /* moonlight */
  119.     sRGB256(255,173,31),        /* sodium */
  120.     sRGB256(255,245,235),        /* daylight */
  121.     sRGB256(255,176,156),        /* dawn */
  122.     sRGB256(255,181,94),        /* afternoon */
  123.     sRGB256(255,163,86),        /* dusk */
  124.     sRGB256(208,163,196),        /* a shade of purple gray */
  125.     sRGB256(137,202,3),        /* Apple Green */
  126.     sRGB256(255,210,0),        /* Apple Yellow */
  127.     sRGB256(230,117,0),        /* Apple Orange */
  128.     sRGB256(163,34,58),        /* Apple Red */
  129.     sRGB256(99,0,116),        /* Apple Purple */
  130.     sRGB256(64,127,179)        /* Apple Blue */
  131.     };
  132.  
  133. short commonColorCount = sizeof(commonColorList)/sizeof(commonColorList[0]);
  134. gxColorSet commonColorSet = nil;
  135.  
  136.  
  137. void InitCommonColors(void)
  138. {
  139.     if (!commonColorSet)
  140.         commonColorSet = GXNewColorSet(gxRGBSpace, commonColorCount, commonColorList);
  141. }
  142.  
  143. void DisposeCommonColors(void)
  144. {
  145.     if (commonColorSet) {
  146.         GXDisposeColorSet(commonColorSet);
  147.         commonColorSet = nil;
  148.     }
  149. }
  150.  
  151.  
  152. gxColor *SetCommonColor(gxColor *dest, commonColor source)
  153. {
  154.     gxRGBColor rgb;
  155.     long actualindex;
  156.     
  157.     if (!commonColorSet)
  158.         InitCommonColors();
  159.     
  160.     actualindex = (source - 1 & 511) % commonColorCount + 1;
  161.     if (actualindex < 1 || actualindex > commonColorCount) {
  162. #ifdef debugging
  163.     GXPostGraphicsError(parameter_out_of_range);
  164. #endif
  165.     actualindex = 0;
  166.     }
  167.     dest->element.indexed.set = commonColorSet;
  168.     dest->element.indexed.index = actualindex;
  169.     dest->space = gxIndexedSpace;
  170.     dest->profile = nil;
  171.     
  172.     GXConvertColor(dest,gxRGBSpace, nil, nil);
  173.     rgb = dest->element.rgb;
  174.     
  175.     if (source & dark) {
  176.         rgb.red >>= 1;
  177.         rgb.green   >>= 1;
  178.         rgb.blue    >>= 1;
  179.     }
  180.     if (source & light) {
  181.         rgb.red += 0xffff - rgb.red >> 1;
  182.         rgb.green   += 0xffff - rgb.green >> 1;
  183.         rgb.blue    += 0xffff - rgb.blue >> 1;
  184.     }
  185.     if (source & warm) {
  186.         rgb.red -= 0xffff - rgb.red >> 2;
  187.         rgb.green   >>= 2;
  188.         rgb.green   = rgb.green + rgb.green + rgb.green;
  189.         rgb.blue    >>= 2;
  190.         rgb.blue    = rgb.blue + rgb.blue + rgb.blue;
  191.     }
  192.     if (source & greenish) {
  193.         rgb.green   -= 0xffff - rgb.green >> 2;
  194.         rgb.red >>= 2;
  195.         rgb.red = rgb.red + rgb.red + rgb.red;
  196.         rgb.blue    >>= 2;
  197.         rgb.blue    = rgb.blue + rgb.blue + rgb.blue;
  198.     }
  199.     if (source & cool) {
  200.         rgb.blue    -= 0xffff - rgb.blue >> 2;
  201.         rgb.red >>= 2;
  202.         rgb.red = rgb.red + rgb.red + rgb.red;
  203.         rgb.green   >>= 2;
  204.         rgb.green   = rgb.green + rgb.green + rgb.green;
  205.     }
  206.     if (source & grayish) {
  207.         rgb.red = 0x3f3f + (rgb.red >> 1); 
  208.         rgb.green   = 0x3f3f + (rgb.green >> 1);
  209.         rgb.blue    = 0x3f3f + (rgb.blue >> 1);
  210.     }
  211.     
  212.     dest->element.rgb = rgb;
  213.     return dest;
  214. }
  215.  
  216.  
  217. commonColor GetCommonColor(const gxColor *source)
  218. {
  219.     gxColor dst;
  220.     
  221.     dst = *source;
  222.     GXConvertColor(&dst, gxIndexedSpace, commonColorSet, nil);
  223.     return dst.element.indexed.index;
  224. }
  225.  
  226.  
  227. void SetShapeCommonColor(gxShape dest, commonColor someColor)
  228. {
  229.     gxColor c;
  230.     
  231.     NilShapeReturn(dest);
  232.     GXSetShapeColor(dest, SetCommonColor(&c, someColor));
  233. }
  234.  
  235.  
  236. void SetInkCommonColor(gxInk dest, commonColor someColor)
  237. {
  238.     gxColor c;
  239.     
  240.     NilInkReturn(dest);
  241.     GXSetInkColor(dest, SetCommonColor(&c, someColor));
  242. }
  243.  
  244.  
  245. commonColor GetInkCommonColor(gxInk source)
  246. {
  247.     gxColor c;
  248.     
  249.     GXGetInkColor(source, &c);
  250.     return GetCommonColor(&c);
  251. }
  252.  
  253.  
  254. commonColor GetShapeCommonColor(gxShape source)
  255. {
  256.     gxColor c;
  257.     
  258.     GXGetShapeColor(source, &c);
  259.     return GetCommonColor(&c);
  260. }
  261.  
  262.  
  263. gxColorSpace GetShapeColorSpace(gxShape source)
  264. {
  265.     if( GXGetShapeType(source) == gxBitmapType ) {
  266.         gxBitmap bits;
  267.         return GXGetBitmap(source, &bits, nil)->space;
  268.     } else {
  269.         gxColor old;
  270.         return GXGetShapeColor(source, &old)->space;
  271.     }
  272. }
  273.  
  274.  
  275. gxColorProfile GetShapeColorProfile(gxShape source)
  276. {
  277.     if( GXGetShapeType(source) == gxBitmapType ) {
  278.         gxBitmap bits;
  279.         return GXGetBitmap(source, &bits, nil)->profile;
  280.     } else {
  281.         gxColor old;
  282.         return GXGetShapeColor(source, &old)->profile;
  283.     }
  284. }
  285.  
  286.  
  287. gxColorSet GetShapeColorSet(gxShape source)
  288. {
  289.     if( GXGetShapeType(source) == gxBitmapType ) {
  290.         gxBitmap bits;
  291.         GXGetBitmap(source, &bits, nil);
  292.         return bits.set;
  293.     } else {
  294.         gxColor oldColor;
  295.         GXGetShapeColor(source, &oldColor);
  296.         if( oldColor.space == gxIndexedSpace )
  297.             return oldColor.element.indexed.set;
  298.         return nil;
  299.     }
  300. }
  301.  
  302.  
  303. gxColorSpace GetInkColorSpace(gxInk source)
  304. {
  305.     gxColor oldColor;
  306.     return GXGetInkColor(source, &oldColor)->space;
  307. }
  308.  
  309.  
  310. gxColorProfile GetInkColorProfile(gxInk source)
  311. {
  312.     gxColor oldColor;
  313.     return GXGetInkColor(source, &oldColor)->profile;
  314. }
  315.  
  316.  
  317. gxColorSet GetInkColorSet(gxInk source)
  318. {
  319.     gxColor oldColor;
  320.  
  321.     GXGetInkColor(source, &oldColor);
  322.     if( oldColor.space == gxIndexedSpace )
  323.         return oldColor.element.indexed.set;
  324.     return nil;
  325. }
  326.  
  327.  
  328. void SetShapeColorSpace(gxShape target, gxColorSpace space)
  329. {
  330.     if( GXGetShapeType(target) == gxBitmapType ) {
  331.         gxBitmap bits;
  332.         GXGetBitmap(target, &bits, nil);
  333.         bits.space = space;
  334.         GXSetBitmap(target, &bits, nil);
  335.     } else {
  336.         gxColor oldColor;
  337.         GXGetShapeColor(target, &oldColor);
  338.         IfErrorReturn(space == gxIndexedSpace && oldColor.element.indexed.set == nil, colorSet_is_nil);
  339.         GXConvertColor(&oldColor, space, space == gxIndexedSpace ? oldColor.element.indexed.set : nil, oldColor.profile);
  340.         GXSetShapeColor(target, &oldColor);
  341.     }
  342. }
  343.  
  344.  
  345. void SetShapeColorProfile(gxShape target, gxColorProfile profile)
  346. {
  347.     if( GXGetShapeType(target) == gxBitmapType ) {
  348.         gxBitmap bits;
  349.         GXGetBitmap(target, &bits, nil);
  350.         bits.profile = profile;
  351.         GXSetBitmap(target, &bits, nil);
  352.     } else {
  353.         gxColor oldColor;
  354.         GXGetShapeColor(target, &oldColor);
  355.         oldColor.profile = profile;
  356.         GXSetShapeColor(target, &oldColor);
  357.     }
  358. }
  359.  
  360.  
  361. void SetShapeColorSet(gxShape target, gxColorSet set)
  362. {
  363.     if( GXGetShapeType(target) == gxBitmapType ) {
  364.         gxBitmap bits;
  365.         GXGetBitmap(target, &bits, nil);
  366.         bits.set = set;
  367.  
  368.     /*** might want to check to see if the old gxColorSpace was not indexed, in which case we need to either post an error
  369.         or remap the gxBitmap to fit this new gxColorSet. We should also check the number of colors in this new set to see if
  370.         they match the old set and post a warning if there are less new colors than could be in the gxBitmap */
  371.  
  372.         GXSetBitmap(target, &bits, nil);
  373.     } else {
  374.         gxColor oldColor;
  375.         GXGetShapeColor(target, &oldColor);
  376.         oldColor.space = gxIndexedSpace;
  377.         oldColor.element.indexed.set = set;
  378.         GXSetShapeColor(target, &oldColor);
  379.     }
  380. }
  381.  
  382.  
  383. void SetInkColorSpace(gxInk target, gxColorSpace space)
  384. {
  385.     gxColor oldColor;
  386.  
  387.     GXGetInkColor(target, &oldColor);
  388.     IfErrorReturn(space == gxIndexedSpace && oldColor.element.indexed.set == nil, colorSet_is_nil);
  389.     GXConvertColor(&oldColor, space, space == gxIndexedSpace ? oldColor.element.indexed.set : nil, oldColor.profile);
  390.     GXSetInkColor(target, &oldColor);
  391. }
  392.  
  393.  
  394. void SetInkColorProfile(gxInk target, gxColorProfile profile)
  395. {
  396.     gxColor oldColor;
  397.  
  398.     GXGetInkColor(target, &oldColor);
  399.     oldColor.profile = profile;
  400.     GXSetInkColor(target, &oldColor);
  401. }
  402.  
  403.  
  404. void SetInkColorSet(gxInk target, gxColorSet set)
  405. {
  406.     gxColor oldColor;
  407.  
  408.     GXGetInkColor(target, &oldColor);
  409.     oldColor.space = gxIndexedSpace;
  410.     oldColor.element.indexed.set = set;
  411.     GXSetInkColor(target, &oldColor);
  412. }
  413.  
  414.  
  415. gxColorSet GetViewDeviceColorSet(gxViewDevice source)
  416. {
  417.     register gxShape bitmapShape = GXGetViewDeviceBitmap(source);
  418.     register gxColorSet result = GetShapeColorSet(bitmapShape);
  419.     if (result)
  420.         GXCloneColorSet(result);
  421.     GXDisposeShape(bitmapShape);
  422.     return result;
  423. }
  424.  
  425.  
  426. void SetViewDeviceColorSet(gxViewDevice target, gxColorSet set)
  427. {
  428.     register gxShape bitmapShape = GXGetViewDeviceBitmap(target);
  429.  
  430.     SetShapeColorSet(bitmapShape, set);
  431.  
  432. /*** Should check for hardware devices and not allow you to change from a hardware direct device to an indexed device */
  433.  
  434.     GXSetViewDeviceBitmap(target, bitmapShape);
  435.     GXDisposeShape(bitmapShape);
  436. }
  437.  
  438.  
  439. gxColorProfile GetViewDeviceColorProfile(gxViewDevice source)
  440. {
  441.     register gxShape bitmapShape = GXGetViewDeviceBitmap(source);
  442.     register gxColorProfile result = GetShapeColorProfile(bitmapShape);
  443.     if (result)
  444.         GXCloneColorProfile(result);
  445.     GXDisposeShape(bitmapShape);
  446.     return result;
  447. }
  448.  
  449.  
  450. void SetViewDeviceColorProfile(gxViewDevice target, gxColorProfile profile)
  451. {
  452.     register gxShape bitmapShape = GXGetViewDeviceBitmap(target);
  453.  
  454.     SetShapeColorProfile(bitmapShape, profile);
  455.     GXSetViewDeviceBitmap(target, bitmapShape);
  456.     GXDisposeShape(bitmapShape);
  457. }
  458.  
  459.  
  460. static char colorSpaceComponentCounts[] = {
  461.     3,            /* rgb */
  462.     4,            /* rgba */
  463.     4,            /* cmyk */
  464.     3,3,                /* hsv, hls */
  465.     3,3,3,3,3,    /* cie & its parasites */
  466.     3,3,3,        /* yiq, other video */
  467.     1,2,                /* gray, grayAlpha */
  468.     3,3,                /* rgb16, rgb32 */
  469.     4,4,                /* argb16, argb32 */
  470.     4,4,                /* cmyk16, cmyk32 */
  471.     2,            /* grayAlpha */
  472.     1            /* indexed */
  473. };
  474.  
  475. long GetColorSpaceComponents(gxColorSpace space)
  476. {
  477.     return colorSpaceComponentCounts[space - 1];
  478. }
  479.  
  480. void SetShapeRGB(gxShape target, gxColorValue red, gxColorValue green, gxColorValue blue)
  481. {
  482.     gxColor c;
  483.     
  484.     NilShapeReturn(target);
  485.     c.space = gxRGBSpace;
  486.     c.profile = nil;
  487.     c.element.rgb.red = red;
  488.     c.element.rgb.green = green;
  489.     c.element.rgb.blue = blue;
  490.     GXSetShapeColor(target, &c);
  491. }
  492.  
  493. void SetInkRGB(gxInk target, gxColorValue red, gxColorValue green, gxColorValue blue)
  494. {
  495.     gxColor c;
  496.     
  497.     NilInkReturn(target);
  498.     c.space = gxRGBSpace;
  499.     c.profile = nil;
  500.     c.element.rgb.red = red;
  501.     c.element.rgb.green = green;
  502.     c.element.rgb.blue = blue;
  503.     GXSetInkColor(target, &c);
  504. }
  505.  
  506. void SetShapeHSV(gxShape target, gxColorValue hue, gxColorValue saturation, gxColorValue value)
  507. {
  508.     gxColor c;
  509.     
  510.     NilShapeReturn(target);
  511.     c.space = gxHSVSpace;
  512.     c.profile = nil;
  513.     c.element.hsv.hue = hue;
  514.     c.element.hsv.saturation = saturation;
  515.     c.element.hsv.value = value;
  516.     GXSetShapeColor(target, &c);
  517. }
  518.  
  519. void SetInkHSV(gxInk target, gxColorValue hue, gxColorValue saturation, gxColorValue value)
  520. {
  521.     gxColor c;
  522.     
  523.     NilInkReturn(target);
  524.     c.space = gxHSVSpace;
  525.     c.profile = nil;
  526.     c.element.hsv.hue = hue;
  527.     c.element.hsv.saturation = saturation;
  528.     c.element.hsv.value = value;
  529.     GXSetInkColor(target, &c);
  530. }
  531.  
  532. void SetShapeGray(gxShape target, gxColorValue gray)
  533. {
  534.     gxColor c;
  535.     
  536.     NilShapeReturn(target);
  537.     c.space = gxGraySpace;
  538.     c.profile = nil;
  539.     c.element.gray = gray;
  540.     GXSetShapeColor(target, &c);
  541. }
  542.  
  543. void SetInkGray(gxInk target, gxColorValue gray)
  544. {
  545.     gxColor c;
  546.     
  547.     NilInkReturn(target);
  548.     c.space = gxGraySpace;
  549.     c.profile = nil;
  550.     c.element.gray = gray;
  551.     GXSetInkColor(target, &c);
  552. }
  553.